home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / status.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  7KB  |  330 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  * 
  4.  *     This program is free software; you can redistribute it and/or modify
  5.  *     it under the terms of the GNU General Public License as published by
  6.  *     the Free Software Foundation; either version 2 of the License, or
  7.  *     (at your option) any later version.
  8.  * 
  9.  *     This program is distributed in the hope that it will be useful,
  10.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *     GNU General Public License for more details.
  13.  * 
  14.  *     You should have received a copy of the GNU General Public License
  15.  *     along with this program; if not, write to the Free Software
  16.  *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */ 
  18.  
  19. #include "mutt.h"
  20. #include "mutt_curses.h"
  21. #include "sort.h"
  22.  
  23. #include <string.h>
  24. #include <ctype.h>
  25. #include <unistd.h>
  26.  
  27. /*
  28.  * %b = number of incoming folders with unread messages [option]
  29.  * %d = number of deleted messages [option]
  30.  * %f = full mailbox path
  31.  * %F = number of flagged messages [option]
  32.  * %h = hostname
  33.  * %l = length of mailbox (in bytes) [option]
  34.  * %m = total number of messages [option]
  35.  * %M = number of messages shown (virutal message count when limiting) [option]
  36.  * %n = number of new messages [option]
  37.  * %p = number of postponed messages [option]
  38.  * %r = readonly/wontwrite/changed flag
  39.  * %s = current sorting method
  40.  * %t = # of tagged messages [option]
  41.  * %v = Mutt version
  42.  *
  43.  * %>X = right justify and pad with "X"
  44.  * %|X = pad with "X" to end of line
  45.  *
  46.  * optional fields:
  47.  *    %?<format_char>?<optional_string>?
  48.  */
  49.  
  50. void mutt_status_line (char *buf, size_t buflen, const char *p)
  51. {
  52.   char *cp;
  53.   char *wptr = buf;
  54.   char tmp[SHORT_STRING];
  55.   char prefix[SHORT_STRING];
  56.   char fmt[SHORT_STRING];
  57.   char optstring[SHORT_STRING];
  58.   char ch;
  59.   int wlen = 0;
  60.   int optional = 0;
  61.   int num_post;
  62.   int len;
  63.  
  64.   buflen--; /* save room for the trailing \0 */
  65.   while (*p && wlen < buflen)
  66.   {
  67.     if (*p == '%')
  68.     {
  69.       p++;
  70.  
  71.       if (*p == '?')
  72.       {
  73.     optional = 1;
  74.     p++;
  75.       }
  76.       else
  77.       {
  78.     optional = 0;
  79.  
  80.     /* eat the format string */
  81.     cp = prefix;
  82.     while (*p && (isdigit (*p) || *p == '.' || *p == '-'))
  83.       *cp++ = *p++;
  84.     *cp = 0;
  85.       }
  86.  
  87.       if (!*p)
  88.     break; /* bad format */
  89.  
  90.       ch = *p++; /* save the character to switch on */
  91.  
  92.       if (optional)
  93.       {
  94.     if (*p != '?')
  95.       break; /* bad format */
  96.     p++;
  97.  
  98.     /* eat the optional part of the string */
  99.     cp = optstring;
  100.     while (*p && *p != '?')
  101.       *cp++ = *p++;
  102.     *cp = 0;
  103.     if (!*p)
  104.       break; /* bad format */
  105.     p++; /* move past the trailing `?' */
  106.       }
  107.  
  108.       tmp[0] = 0;
  109.       switch (ch)
  110.       {
  111.     case '>': /* right justify rest of line */
  112.  
  113.       if (!*p)
  114.         break; /* bad format */
  115.       ch = *p++; /* pad character */
  116.       mutt_status_line (tmp, sizeof (tmp), p);
  117.       len = COLS - wlen - strlen (tmp);
  118.       while (len > 0)
  119.       {
  120.         *wptr++ = ch; /* pad character */
  121.         wlen++;
  122.         len--;
  123.       }
  124.       break;
  125.  
  126.     case '|': /* pad to end of line */
  127.  
  128.       if (!*p)
  129.         break; /* bad format */
  130.       ch = *p++;
  131.       if (buflen > COLS)
  132.         buflen = COLS;
  133.       while (wlen < buflen)
  134.       {
  135.         *wptr++ = ch; /* pad character */
  136.         wlen++;
  137.       }
  138.       break;
  139.  
  140.         case 'b':
  141.  
  142.       if (!optional)
  143.       {
  144.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  145.         snprintf (tmp, sizeof (tmp), fmt, mutt_buffy_check ());
  146.       }
  147.       else if (!mutt_buffy_check ())
  148.         optional = 0;
  149.       break;
  150.  
  151.     case 'd':
  152.  
  153.       if (!optional)
  154.       {
  155.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  156.         snprintf (tmp, sizeof (tmp), fmt, Context ? Context->deleted : 0);
  157.       }
  158.       else if (!Context || !Context->deleted)
  159.         optional = 0;
  160.       break;
  161.  
  162.     case 'h':
  163.  
  164.       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  165.       snprintf (tmp, sizeof (tmp), fmt, Hostname);
  166.       break;
  167.  
  168.     case 'f':
  169.  
  170.       snprintf (fmt, sizeof(fmt), "%%%ss", prefix);
  171.       if (Context && Context->path)
  172.       {
  173.         strfcpy (prefix, Context->path, sizeof (prefix));
  174.         mutt_pretty_mailbox (prefix);
  175.       }
  176.       else
  177.         strfcpy (prefix, "(no mailbox)", sizeof (prefix));
  178.       snprintf (tmp, sizeof (tmp), fmt, prefix);
  179.       break;
  180.  
  181.     case 'F':
  182.  
  183.       if (!optional)
  184.       {
  185.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  186.         snprintf (tmp, sizeof (tmp), fmt, Context ? Context->flagged : 0);
  187.       }
  188.       else if (!Context || !Context->flagged)
  189.         optional = 0;
  190.       break;
  191.  
  192.     case 'l':
  193.  
  194.       if (!optional)
  195.       {
  196.         char size[5];
  197.  
  198.         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  199.         mutt_pretty_size (size, sizeof (size), Context ? Context->size : 0);
  200.         snprintf (tmp, sizeof (tmp), fmt, size);
  201.       }
  202.       else if (!Context || !Context->size)
  203.         optional = 0;
  204.       break;
  205.  
  206.     case 'm':
  207.  
  208.       if (!optional)
  209.       {
  210.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  211.         snprintf (tmp, sizeof (tmp), fmt, Context ? Context->msgcount : 0);
  212.       }
  213.       else if (!Context || !Context->msgcount)
  214.         optional = 0;
  215.       break;
  216.  
  217.     case 'M':
  218.  
  219.       if (!optional)
  220.       {
  221.         snprintf (fmt, sizeof(fmt), "%%%sd", prefix);
  222.         snprintf (tmp, sizeof(tmp), fmt, Context ? Context->vcount : 0);
  223.       }
  224.       else if (!Context || Context->vcount == Context->msgcount)
  225.         optional = 0;
  226.       break;
  227.  
  228.     case 'n':
  229.  
  230.       if (!optional)
  231.       {
  232.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  233.         snprintf (tmp, sizeof (tmp), fmt, Context ? Context->new : 0);
  234.       }
  235.       else if (!Context || !Context->new)
  236.         optional = 0;
  237.       break;
  238.  
  239.     case 'p':
  240.  
  241.       num_post = mutt_num_postponed ();
  242.       if (!optional)
  243.       {
  244.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  245.         snprintf (tmp, sizeof (tmp), fmt, num_post);
  246.       }
  247.       else if (!num_post)
  248.         optional = 0;
  249.       break;
  250.  
  251.     case 'r':
  252.  
  253.       if (Context)
  254.         tmp[0] = (Context->readonly || Context->dontwrite) ? StChars[2] :
  255.               (Context->changed || Context->deleted) ? StChars[1] : StChars[0];
  256.       else
  257.         tmp[0] = StChars[0];
  258.       tmp[1] = 0;
  259.       break;
  260.  
  261.     case 's':
  262.  
  263.       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  264.       if ((Sort & SORT_MASK) == SORT_THREADS)
  265.          snprintf (prefix, sizeof (prefix),
  266.                "%sthreads/%s%s%s",
  267.                (Sort & SORT_REVERSE) ? "reverse-" : "",
  268.                (SortAux & SORT_REVERSE) ? "reverse-" : "",
  269.                (SortAux & SORT_LAST) ? "last-" : "",
  270.                mutt_getnamebyvalue ((SortAux & SORT_MASK), SortMethods));
  271.       else
  272.         snprintf (prefix, sizeof (prefix), "%s%s",
  273.               (Sort & SORT_REVERSE) ? "reverse-" : "",
  274.               mutt_getnamebyvalue ((Sort & SORT_MASK), SortMethods));
  275.                
  276.       snprintf (tmp, sizeof (tmp), fmt, prefix);
  277.       break;
  278.  
  279.     case 't':
  280.  
  281.       if (!optional)
  282.       {
  283.         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
  284.         snprintf (tmp, sizeof (tmp), fmt, Context ? Context->tagged : 0);
  285.       }
  286.       else if (!Context || !Context->tagged)
  287.         optional = 0;
  288.       break;
  289.  
  290.     case 'v':
  291.  
  292.       snprintf (fmt, sizeof (fmt), "Mutt %%s");
  293.       snprintf (tmp, sizeof (tmp), fmt, VERSION);
  294.       break;
  295.  
  296.     case 0:
  297.  
  298.       *buf = 0;
  299.       return;
  300.  
  301.     default:
  302.  
  303.       snprintf (tmp, sizeof (tmp), "%%%s%c", prefix, ch);
  304.       break;
  305.       }
  306.  
  307.       if (optional)
  308.     mutt_status_line (tmp, sizeof (tmp), optstring);
  309.  
  310.       if ((len = strlen (tmp)))
  311.       {
  312.     if (len + wlen > buflen)
  313.     {
  314.       if ((len = buflen - wlen) < 0)
  315.         len = 0;
  316.     }
  317.     memcpy (wptr, tmp, len);
  318.     wptr += len;
  319.     wlen += len;
  320.       }
  321.     }
  322.     else
  323.     {
  324.       *wptr++ = *p++;
  325.       wlen++;
  326.     }
  327.   }
  328.   *wptr = 0;
  329. }
  330.